/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package practica2_minimax;

/**
 *
 * @author William
 */
public class minimax {
    private int[] tableroPos;
    private int turno, profundidad;
    public nodoTablero raiz;
    private int movimiento;

    public void setTablero(int[] tablero)
    {
        tableroPos = tablero;
    }

    public void setProfundidad(int prof)
    {
        profundidad = prof;
    }

    public void setTurno(int turno)
    {
        this.turno = turno;
    }
    public int determinarGanador()
    {
        int resultado = -1;///-1 para empate; 0 para jugador 1; 1 para jugador 2
        //verificacion horizontal
        if(tableroPos[0] != -1 && tableroPos[0] == tableroPos[1] && tableroPos[0] == tableroPos[2])
            return tableroPos[0];
        else if(tableroPos[3] != -1 && tableroPos[3] == tableroPos[4] && tableroPos[3] == tableroPos[5])
            return tableroPos[3];
        else if(tableroPos[6] != -1 && tableroPos[6] == tableroPos[7] && tableroPos[6] == tableroPos[8])
            return tableroPos[6];
        //verificacion vertical
        if(tableroPos[0] != -1 && tableroPos[0] == tableroPos[3] && tableroPos[0] == tableroPos[6])
            return tableroPos[0];
        else if(tableroPos[1] != -1 && tableroPos[1] == tableroPos[4] && tableroPos[1] == tableroPos[7])
            return tableroPos[1];
        else if(tableroPos[2] != -1 && tableroPos[2] == tableroPos[5] && tableroPos[2] == tableroPos[8])
            return tableroPos[2];
        //verificacion diagonal
        if((tableroPos[0] != -1) && (tableroPos[0] == tableroPos[4]) && (tableroPos[0] == tableroPos[8]))
            return tableroPos[0];
        else if(tableroPos[2] != -1 && tableroPos[2] == tableroPos[4] && tableroPos[2] == tableroPos[6])
            return tableroPos[2];
        return resultado;
    }

    public int[] jugarPC(int turno)
    {
        if(turno == 0)
            raiz = new nodoTablero(tableroPos, 1);
        else
            raiz = new nodoTablero(tableroPos, 0);
        this.turno = turno;
        nodoTablero jugada = minimaxEval();
        if(jugada != null)
        {
            return jugada.tablero;
        }

        return raiz.tablero;
    }

    public void setIndiceMovimiento(int i)
    {
        movimiento = i;
    }

    public int getIndiceMovimiento()
    {
        return movimiento;
    }

    public int mejorJugada()
    {
        int pos = 0;
        int val = 0;
        for(int i = 0; i < raiz.hijos.length; i++)
        {
            nodoTablero nt = raiz.hijos[i];
            if(nt.getEvaluacion() < val && tableroPos[i] == -1)
                pos = i;
        }
        System.out.println("La mejor jugada es en la posicion " + pos);
        return pos;
    }

    public int espaciosEnBlanco(int[] pTablero)
    {
        int cant = 0;

        for(int i = 0; i < 9; i++)
        {
            if(pTablero[i] == -1)
            {
                cant++;
            }
        }
        return cant;
    }

    public int tableroLleno()
    {
        int val = 1;//esta lleno
        for(int i = 0; i < 9; i++)
        {
            if(tableroPos[i] == -1)
                val = 0;
        }
        return val;
    }

    public nodoTablero minimaxEval(){
	nodoTablero mov = null;
        int max;
	int cmax;
	max = Integer.MIN_VALUE;
        raiz.generarHijos();
	for(int i = 0; raiz.hijos != null && i < raiz.hijos.length; i++){
		cmax = valorMax(raiz.hijos[i], profundidad);
		if(cmax > max){
			max = cmax;
			mov = raiz.hijos[i];
		}
	}
	return mov;
    }

    private int valorMax(nodoTablero nodo, int prof){
	int vmax;
        nodo.generarHijos();
	if(nodo.hijos == null || prof == 0){
		return nodo.getEvaluacion();
	}
	else{
		vmax = Integer.MIN_VALUE;
		for(int i = 0; i < nodo.hijos.length; i++){
			vmax = Math.max(vmax, valorMin(nodo.hijos[i], prof - 1));
		}
                return vmax;
	}
    }

    private int valorMin(nodoTablero nodo, int prof){
	int vmin;
        nodo.generarHijos();
	if(nodo.hijos == null || prof == 0){
		return nodo.getEvaluacion();
	}
	else{
		vmin = Integer.MAX_VALUE;
		for(int i = 0; i < nodo.hijos.length; i++){
			vmin = Math.min(vmin, valorMax(nodo.hijos[i], prof - 1));
		}
                return vmin;
	}

    }
}
